from langchain_community.document_loaders import PyPDFLoader
from langchain_unstructured import UnstructuredLoader  # 使用新版本的UnstructuredLoader
from typing import Union, List, Dict
from utils.file_dir import get_doc_md_dir
import os
import re


def clean_document_text(text: str) -> str:
    """清理文档文本，移除不必要的行号和其他噪音"""
    # 1. 移除单独的数字行（行号）
    cleaned = re.sub(r'^\d+\s*$', '', text, flags=re.MULTILINE)

    # 2. 移除行首的数字+空格模式（行内行号）
    cleaned = re.sub(r'^\d+\s+', '', cleaned, flags=re.MULTILINE)

    # 3. 合并连续的JSON结构
    cleaned = re.sub(r'"code":\s*\d+,', '"code": 0,', cleaned)

    # 4. 优化JSON格式显示
    cleaned = re.sub(r'{\s*"', '{\n    "', cleaned)
    cleaned = re.sub(r',\s*"', ',\n    "', cleaned)
    cleaned = re.sub(r'}\s*$', '}\n', cleaned, flags=re.MULTILINE)

    # 5. 移除多余的空白行
    cleaned = re.sub(r'\n\s*\n', '\n\n', cleaned)

    return cleaned.strip()


def format_interface_document(text: str) -> str:
    """格式化接口文档，添加结构化和标题"""
    # 1. 提取主要章节
    sections = re.split(r'\n\d+\.\d+\s+', text)

    # 2. 处理每个章节
    formatted = ""
    for i, section in enumerate(sections):
        if i == 0:
            # 处理概述部分
            formatted += section.strip() + "\n\n"
            continue

        # 提取接口名称和描述
        parts = re.split(r'\n(?=请求方式)', section, 1)
        if len(parts) < 2:
            formatted += section.strip() + "\n\n"
            continue

        title_desc, details = parts

        # 格式化标题
        title_match = re.match(r'^(.+?)\n(.+)$', title_desc, re.DOTALL)
        if title_match:
            title = title_match.group(1).strip()
            desc = title_match.group(2).strip()
            formatted += f"### 接口 {i}: {title}\n"
            formatted += f"**描述**: {desc}\n\n"
        else:
            formatted += f"### 接口 {i}: {title_desc.strip()}\n\n"

        # 格式化详细信息
        formatted += details.strip() + "\n\n"

    return formatted


def read_and_extract_interfaces(file_path: str) -> str:
    """读取Markdown文件并提取接口信息"""
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            md_content = f.read()

        # 提取接口数据
        interfaces = extract_interface_data(md_content)

        # 格式化输出
        return format_interface_data(interfaces)

    except Exception as e:
        return f"处理文件时出错: {e}"


def load_document(file_path: str) -> Union[str, None]:
    """读取 Word 或 PDF 文件并返回优化后的文本内容"""
    try:
        # 检查文件是否存在
        if not os.path.exists(file_path):
            raise FileNotFoundError(f"文件不存在: {file_path}")

        # 处理 PDF 文件
        if file_path.lower().endswith('.pdf'):
            loader = PyPDFLoader(file_path)
            pages = loader.load()
            raw_text = "\n\n".join(page.page_content for page in pages)

        # 处理 Word 文件 (.doc, .docx)
        elif file_path.lower().endswith(('.doc', '.docx')):
            # 使用 UnstructuredLoader 替代旧版加载器
            loader = UnstructuredLoader(file_path, mode="elements")
            documents = loader.load()
            raw_text = "\n\n".join(doc.page_content for doc in documents)
            print(f"Word 文件内容加载成功。{raw_text}")
        else:
            raise ValueError("不支持的文件格式。仅支持 PDF 和 Word 文档。")

        # 清理和优化文本
        cleaned_text = clean_document_text(raw_text)
        return format_interface_document(cleaned_text)

    except Exception as e:
        print(f"文档加载错误: {e}")
        return None

# 保存word文件的接口文档到固定md文档中
def save_docx_content(file_path: str):
    print("处理 Word 文件:")
    docx_content = load_document(file_path)
    if docx_content:
        # 保存优化后的内容到文件
        output_file = get_doc_md_dir("optimized_interface_doc.md")
        with open(output_file, "w", encoding="utf-8") as f:
            f.write(docx_content)
        print(f"优化后的文档已保存到: {output_file}")
        # print("\n文档预览:\n" + docx_content)

    else:
        print("无法加载 Word 文件内容。")

# 保存word文件到固定md文档中
def save_function_docx_content(file_path: str):
    print("处理 Word 文件:")
    docx_content = load_document(file_path)
    if docx_content:
        # 保存优化后的内容到文件
        output_file = get_doc_md_dir("optimized_function_doc.md")
        with open(output_file, "w", encoding="utf-8") as f:
            f.write(docx_content)
        print(f"优化后的文档已保存到: {output_file}")

    else:
        print("无法加载 Word 文件内容。")

def format_interface_data(interfaces: List[Dict]) -> str:
    """格式化接口数据为可读文本"""
    output = ""

    for i, interface in enumerate(interfaces, 1):
        output += f"接口 {i}: {interface['接口名称']}\n"
        output += f"描述: {interface['接口描述']}\n"
        output += f"方法: {interface['请求方法']}\n"
        output += f"URL: {interface['请求URL']}\n"

        if interface['请求参数']:
            output += "参数:\n"
            for param in interface['请求参数']:
                output += f"  - {param['name']} ({param['type']}): {param['description']}\n"
                output += f"    必填: {param['required']}, 默认值: {param['default']}\n"
        else:
            output += "参数: 无\n"

        output += "返回示例:\n"
        output += interface['返回示例'] + "\n\n"
        output += "-" * 80 + "\n\n"

    return output


def extract_interface_data(md_content: str) -> List[Dict]:
    """从Markdown内容中提取所有接口相关信息"""
    # 使用更灵活的正则表达式匹配各种标题格式
    pattern = r'(?:### 接口 \d+:|^\d+\.\d+\s*[^\n]+)'
    interface_sections = re.split(pattern, md_content, flags=re.MULTILINE)[1:]
    titles = re.findall(pattern, md_content, flags=re.MULTILINE)

    interfaces = []

    for i, section in enumerate(interface_sections):
        try:
            # 提取标题
            title = titles[i].strip() if i < len(titles) else f"接口 {i + 1}"

            # 提取接口名称
            if "###" in title:
                interface_name = re.split(r':\s*', title, maxsplit=1)[-1].strip()
            else:
                interface_name = re.sub(r'^\d+\.\d+\s*', '', title).strip()

            # 提取描述
            desc_match = re.search(r'描述\s*:\s*([^\n]+)', section)
            description = desc_match.group(1).strip() if desc_match else ""

            # 提取请求方式
            method_match = re.search(r'请求方式\s*：\s*(\w+)', section)
            method = method_match.group(1) if method_match else "UNKNOWN"

            # 提取请求URL
            url_match = re.search(r'请求url\s*：\s*([^\n]+)', section)
            url = url_match.group(1).strip() if url_match else "UNKNOWN"

            # 提取请求参数
            params_start = section.find("请求参数：")
            params_end = section.find("接口返回：", params_start)
            params_text = section[params_start:params_end] if params_end != -1 else ""

            # 解析参数表格
            parameters = []
            param_rows = re.findall(r'(\w+)\s+(\w+)\s+([^\n]+?)\s+(\S+)\s+(\S+)', params_text)
            for row in param_rows:
                parameters.append({
                    "name": row[0],
                    "type": row[1],
                    "description": row[2],
                    "required": row[3],
                    "default": row[4]
                })

            # 提取返回示例
            response_start = section.find("接口返回：")
            response_text = section[response_start:] if response_start != -1 else ""

            # 提取返回JSON（保留原始格式）
            response_example = ""
            json_match = re.search(r'\{[\s\S]+\}', response_text)
            if json_match:
                response_example = json_match.group(0).strip()

            # 添加到接口列表
            interfaces.append({
                "接口名称": interface_name,
                "接口描述": description,
                "请求方法": method,
                "请求URL": url,
                "请求参数": parameters,
                "返回示例": response_example
            })

        except Exception as e:
            print(f"解析接口时出错: {e}")
            continue

    return interfaces


# 封装读取word文档，保存为md文件，然后返回md文件格式的接口数据
def read_interface_datas():
    # 固定读取这里的接口文档信息，每次都会进行更新
    save_docx_content(get_doc_md_dir("接口文档.docx"))
    interface_data = read_and_extract_interfaces(get_doc_md_dir("optimized_interface_doc.md"))
    return interface_data


# 通过传入文件路径，读取word文档，保存为md文件，然后返回md文件格式的接口数据
def read_interface_datas_from_file(file_path: str):
    # 固定读取这里的接口文档信息，每次都会进行更新
    save_function_docx_content(get_doc_md_dir(file_path))
    interface_data = read_and_extract_interfaces(get_doc_md_dir("optimized_interface_doc.md"))
    return interface_data


# 替换原有的清理代码
def clean_json_response(content):
    # 尝试提取 JSON 代码块
    match = re.search(r'```json\s*(.*?)\s*```', content, re.DOTALL)
    if match:
        return match.group(1)

    # 尝试提取纯 JSON
    match = re.search(r'(\{.*\}|\[.*\])', content, re.DOTALL)
    if match:
        return match.group(0)

    # 最后尝试基本清理
    return re.sub(r'```|`|\s+$', '', content, flags=re.DOTALL)

# 使用示例
if __name__ == "__main__":
    # 替换为你的文件路径
    # docx_file = r"D:\007\debug\apidemokeywordspyts\zdebug\readdock\接口文档.docx"
    # save_docx_content(docx_file)
    read_interface_datas()
